package Study0;

import java.util.Scanner;

/*类
* 和C语言中的自定义结构体类似的意思差不多
* 不同的类中有方法，有变量，有函数......等待不语言中的结构体多多了*/
class Demo1 {
    public String name; // 字段，成员变量，非静态变量，类实例化后才产生，静态方法无法访问的，静态的是和类一起加载的
    public int age; //   public 公开的字段，成员变量,类变量 ,类实例化后才产生

}



class Demo2 {
//    属性
    public String name; // public 公开的字段，非静态的成员变量，类实例化后才产生，静态方法无法访问的，静态的是和类一起加载的
    public int age;     // public 公开的字段，非静态的成员变量，类实例化后才产生，静态方法无法访问，静态的是和类一起加载的
    /*非静态之间可以互相访问，方法，变量*/
//  方法：
    public void getName () {
        System.out.println("name()!");
        age = 19;
    }
    /*非静态之间可以互相访问，方法，变量*/

    public void getAge () {
        System.out.println("age()!");
        name = "hello world";
    }


}


class Demo3 { // 类， 一般一个文件，只定义一个类的，类不可以重名，在同一个文件夹中，因为同一个文件夹中不可以放同名的文件
    String name; // 在类中没有加修饰符，默认是包访问权限 公开的，非静态是在类实例化才产生的，而静态和类一起加载的，静态的不可以访问非静态的
    int age; // 在类中没有加修饰符，默认是包访问权限 公开的，非静态是在类实例化才产生的，而静态是和类一起加载的，静态的不可以访问非静态的
    /*非静态之间可以互相访问，变量，方法，以及静态的变量，方法*/

    public void getEat () {   // 类中的 public 公开的方法，
        System.out.println("getEat()!");
    }

    public void getSleep () {
        System.out.println("getSleep()!");
    }
}


class Demo4 {
    public String name; // public 公开的字段——成员变量，静态的是在实例化类才产生，非静态的是和类一起加载的，静态的无法访问非静态的
    public int age;  // public 公开的字段——成员变量，静态的是在实例化类才产生的，非静态的是和类一起加载的，静态的无法访问非静态的
    /*静态的可以相互访问，变量，方法，以及静态的方法，变量*/

    public static int size = 10; // static 静态的变量，类中，静态的之间可以相互访问，
                                 // 但是不能访问非静态的，需要通过实例化对象，来访问
    public void sleep() {  // 方法
        System.out.println("sleep()!");
    }

}



class Demo5 {
    public String name;
    public int age; // public 公开的字段——成员变量，静态的是在实例化类才产生的，非静态的是和类一起加载的，静态的不可以访问静态的
    public char ch;
    public boolean flg;
    public static int size; // static 静态的，和C语言中的有点类似，静态之间可以相互访问，
                            // 但是静态的不可以访问非静态的，需要实例化对象后，通过对象访问，
                            // 多个对象共用该一个静态变量
    public void eat() {
        int num = 10;  // 局部变量
        System.out.println("eat()!");
    }

    public static void test() {
        System.out.println("static");
    }

}

class Demo6 {
    public String name;
    public int age; // 字段——成员变量，public 公开的，非静态是在类实例化才产生的，静态的是和类一起加载的，
    public char ch; // 静态的无法访问非静态的，需要实例化对象，通过实例化对象来访问到
    public boolean flg;


}


class Demo7 {
//    字段成员初始化 ,一般字段是不初始化的，因为后面会赋值修改的
    public String name = "小华";  // public 公开的,字段——成员变量，非静态的是在类的实例化才产生的，静态的是和类一起加载的
    public int age = 18;

    public void show(){
        System.out.println("我叫"+name+"今年"+age+"岁"); // 非静态之间可以相互访问方法，变量，以及静态的方法，变量
    }
}



class Demo8 {
    public int a = 0; // 字段——成员变量，public 公开的，非静态变量是在类实例化才产生，
    public static int count = 0; //public 公开的 static 静态的，是和类一起加载的，多个对象共用一个static静态
}


class Demo9 {
    public int age; // 非静态 public 公开的，非静态的是在类实例化才产生的，
    public static int size; // static 静态的，public 公开的，静态的是和类一起加载的，

    public void test() { // 非静态方法：public公开的，非静态的之间可以互相访问方法，变量，以及静态的方法，变量
        size = 999; // 非静态的访问静态的——没有问题
        age = 9; // 非静态的访问非静态的——也没有问题
        System.out.println(size);
        System.out.println(age);
    }
    public static void testSta() { // static 静态方法 public 公开的，静态的是和类一起加载的
        size = 100;
//        age = 10; 报错，静态的无法访问非静态的，需要实例化对象
        System.out.println(size);
        /*static静态的可以访问静态的，不可以访问非静态的，必须实例化对象后，通过对象访问非静态的
        原因是：非静态的是在类实例化后，才被产生的，而静态的是和类一起加载的，类加载好了，可非静态的类未实例化
        就是还不在内存中，无法访问一个还没有产生的方法，变量的
        * 非静态的可以访问非静态的，也可以访问静态的，
        * */
    }

}



class Demo10 {
    public static void fun() {
        System.out.println("static 静态的方法");
    }

    public void fun2() {
        System.out.println("非静态的方法");
    }
    public void test1() {
        fun(); // 非静态方法的访问静态的方法，可以
        fun2(); // 非静态的方法访问非静态的。可以
    }

    public static void test2() {
        fun(); // 静态方法的访问静态的方法，
//        fun2(); 报错，静态的无法直接访问非静态的方法；
    }

}


class Demo11 {
    public int age; // 实例变量
    public String name; // 实例变量
    public String sex; // 字段
    public static int count; // 类变量也叫静态变量，编译时已经产生了，是和类本身；且只有一份，存放在方法区中
    public final int SIZE = 10; // 被final修饰的叫常量，也属于对象，被final 修饰，后续不可更改的，不然报错的
    public static final int COUNT = 99;

    public void eat() { // 实例方法
        int a = 10; // 局部变量，在Jvm栈区
        System.out.println("eat()!");
    }

    public void sleep() { // 实例方法
        System.out.println("sleep()!");
    }


    public static void staticTest() { // 静态方法
//        sex = "mun"; error
        System.out.println("staticTest()!");
    }

}


class Demo12 {
    /*private / public 这两个关键字表示 “访问权限控制”
    * 被public 修饰的成员或者成员方法，可以直接被类的调用者使用
    * 被private 修饰的成员变量或者成员方法，不能被类的调用者使用
    * 换句话说，类的使用者根本不需要知道，也不需要关注一个类有那些private的成员，从而让
    * 类的调用者以更低的成本来使用类*/
    private String name = "你好世界"; // 被 private修饰的字段或者方法只能在本类中访问使用，与C语言中的 static 类似
    private int age = 18;  // 被private 修饰的字段或者方法只能在本类中访问使用，与C语言中的 static 类似

    public void show() { // public 公开的
        System.out.println("我叫"+name+"今年"+age+"岁");
    }

}


class Demo13 {
    private String name; // private 修饰的字段只能在本类中可以访问使用
    private int age;  // private 修饰的字段只能在本类中可以访问使用

    public String getName() { // 返回接口
        return this.name; // 使用this.表示调用该方法的对象
    }

    public int getAge() { // 返回接口
        return this.age;// 使用this.表示调用该方法的对象
    }

    public void setName(String name) { // 设置属性，接口
        this.name = name; // this.当前变量的，引用，要习惯使用this.可读性高
    }

    public void setAge(int age) { // 设置属性，接口
        this.age = age; // this.当前变量的，引用，要习惯使用this.可读性高
    }
}



class Demo14 {
    /*getName 即为getter方法，表示获取这个成员的值
    * setName 即为setter方法，表示设置这个成员的值
    * 当set 方法的形参名字和类中的成员属性的名字一样的时候，如果不适用this. 相当于局部变量优先的自我赋值
    * 出了局部变量的作用域，释放空间，并没有让对象中的字段赋值到，this.表示当前实例的引用，该对象的字段
    * 不是所有的字段都一定要提供 setter / getter 方法的，而是根据实际情况决定提供哪种方法（可以setter/getter 在一起的）
    * */
    private String name; // 被 private 修饰的方法或字段只能在本类中访问使用
    private int age; // 被 private 修饰的方法或字段只能在本类中访问使用

    public void setName(String name) {
        this.name = name; // 使用this 引用，表示调用该方法的对象
    }
    public void setAge(int age) {
        this.age = age; // 使用this.表示调用该方法的对象
    }
    public String getName() {
        return this.name; // 使用this.表示调用该方法的对象
    }
    public void show() {
        System.out.println("name:"+name+" age "+age);
    }
}
class Demo15 {
    private String name; // 被 private 修饰的方法或字段只能在该类中访问使用

    public void setName(String name) {
        name = name; // 不能这样写，局部变量优先
        /*这其实就是自己给自己赋值了，而且还是局部变量赋值自己给自己赋值，局部变量出了作用域，释放空间，了
        对象当中的name并没有被修改到的，*/
//        应该加上 this. 引用该对象中的字段
        this.name = name; // 使用this. 表示引用该对象的字段
    }
    public String getName() {
        return this.name; // 被this.修饰 表示引用该对象中的字段
    }
}


class Demo16 {
    private String name;
    private int age;

//    重新实现一下object类的toString()的方法
//    object是所有类的父类（祖先）快捷键 Alt + lnsert
//   @Override 注解：这个注解指的是这个方法是重新写的
    @Override
    public String toString() {
        return "Demo16{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}


class Demo17 {
    private int num ;
    private String str;

    @Override  // 重写
    public String toString() {
        return "Demo17{" +
                "num=" + num +
                ", str='" + str + '\'' +
                '}';
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }
}
public class Study09 {
//    Demo17
    public static void main(String[] args) {
        Demo17 demo17 = new Demo17();
        demo17.setNum(999);
        demo17.setStr("Hello World");
        System.out.println(demo17); // 对象名
    }



//    Demo16
    public static void main16(String[] args) {
        Demo16 demo16 = new Demo16();
        demo16.setName("你好世界");
        demo16.setAge(18);
        System.out.println(demo16);
    }


//    Demo15
    public static void main15(String[] args) {
        Demo15 demo15 = new Demo15(); // new 一个对象，创建一个对象，实例化对象，可以new多个对象，每个对象相互独立，互不干扰
        demo15.setName("你好世界  Hello World");
        System.out.println(demo15.getName());
        /*好好习惯使用上 this. 提高代码质量，增加代码的可读性*/
    }


//    Dem014
    public static void main14(String[] args) {
        Demo14 demo14 = new Demo14(); // new 一个对象，创建对象，实例化对象，可以new多个对象，每个对象相互独立，互不干扰的
        demo14.setName("hello world");
        String name = demo14.getName();
        demo14.setAge(18);
        demo14.show();
    }
//    Demo13
    public static void main13(String[] args) {
        Demo13 demo13 = new Demo13(); // new 一个对象，创建对象，实例化对象，可以new多个对象，每个对象相互独立，互不干扰
        demo13.setName("你好世界");
        demo13.setAge(18);
        System.out.println("姓名:"+demo13.getName());
        System.out.println("年龄:"+demo13.getAge());
    }


//    Demo12
    public static void main12(String[] args) {
        Demo12 demo12 = new Demo12(); // new 一个对象，创建对象，实例化对象，可以new多个对象，但是每个对象是相互独立的，互不干扰的
//        demo12.age = 10; 报错，被private 修饰的方法的字段，只能在对应的类中访问使用
        demo12.show();


    }


//    Demo11
    public static void main11(String[] args) {
        Demo11 demo11 = new Demo11();
        System.out.println(demo11.age); // 默认值0，非静态实例 (对象.字段)
        System.out.println(demo11.name); // null .非静态实例(对象.字段)
        System.out.println(Demo11.COUNT); // 99 静态(类名.字段)
        System.out.println(demo11.count);
        demo11.eat();
        demo11.sleep();
        /*总结：
        * 所有被 static 修饰的方法或者属性，全部不依赖对象，方法可以直接调用(类名.静态方法)*，或调用成员(类名.静态成员)/
    }


//    Demo10
    public static void main10(String[] args) {
        Demo10 demo10 = new Demo10(); // new 一个对象，实例化对象，new多个对象，但是每个对象，互相独立，互不干扰
        demo10.test1();
        Demo10.test2();
        /*如果在任何方法上应用 static 关键字，此方法称为静态方法
        * 1.静态方法属于类，而不属于类的对象
        * 2.可以直接调用静态的方法,而无需创建类的实例化，(类名+.+静态的方法)
        * 3.静态方法可以访问静态的数据中的成员变量，(类名+.+静态成员名)，并可以更改静态的数据成员中的值
        * 4.静态方法和实例无关，而是和类相关，因此这两种情况：
        * 1. 静态方法不能直接使用非静态数据成员或调用非静态方法（非静态的数据成员和方法都是和实例相关的）
        * 说白了就是静态的可以访问静态的成员，方法，（类名.静态方法名或者静态数据成员），但是不能直接访问非静态
        * 需要实例化类，
        * 非静态的可以访问直接访问非静态,和静态的 方法，字段。
        * 之所以这样是因为：
        * 非静态的是在类实例化后，才会创建起来，而静态的是和类一起加载的，
        * 当静态的已经加载后了，而非静态的没有实例化对象，还没有创建起来，
        * 静态的无法访问没有创建的咚咚咚
        * */

    }


//  Demo9
    public static void main9(String[] args) {
        Demo9 demo9 = new Demo9(); // new 一个对象，产生一个对象，实例化对象，可以new多个对象，
        // 但是每一个对象都是相互独立的，互不干扰的
        demo9.test(); // 非静态的访问方法的方式：(对象.非静态方法名)
        Demo9.testSta(); // 静态的访问方法的方式：(类名.静态方法名)

    }
//    Demo8
    public static void main8(String[] args) {
        Demo8 demo1 = new Demo8(); // new 一个对象，产生对象，实例化对象，可以new多个对象，但每个对象相互独立，互不干扰
        demo1.a++; // 访问非静态的字段——成员变量方式：(对象名.非静态变量名)  // 1
        Demo8.count++; // 访问静态的成员变量方式 (类名.静态成员名)   // 1
        System.out.println("a:"+demo1.a); // 1
        System.out.println("count:"+Demo8.count); // 1

        Demo8 demo2 = new Demo8(); // new 一个对象，产生对象，实例化对象，可以new 多个对象，但每个对象是相互独立的，互不干扰的
        demo2.a++; // 访问非静态的字段——成员变量方式：(对象名.非静态变量) // 1
        Demo8.count++; // 访问静态的成员变量的方式：(类名. 静态成员名) // 2
        System.out.println("a:"+demo2.a); // 1
        System.out.println("count:"+Demo8.count); // 2
        /*Java 中静态属性，方法和类相关，和具体的实例无关，
        * 换句话说：就是同一个类中不同的实例化(对象)共同用一个静态属性，方法*/

    }


// Demo7
    public static void main7 (String[] args) {
        Demo7 demo7 = new Demo7(); // new 一个对象，产生一个对象，实例化对象，可以实例化多个对象，
                                   // 每个对象是相互独立的，互不干扰的
        demo7.show();
    }



//    Demo6
    public static void main6(String[] args) {
        Demo6 demo6 = new Demo6(); // new 一个对象，产生对象，实例化对象，可以实例化多个对象，
                                   // 但是每个对象是相互独立的，互不干扰的
//        访问字段——成员变量：对象. 字段
        System.out.println("name:"+demo6.name); // 未初始化的String 字段类型 值为 null,
        System.out.println("age:"+demo6.age); // 未初始化的 Int 字段值类型为 0 ；
        System.out.println("ch:"+demo6.ch); // 未初始化的 char 字段类型 值为：\u0000
        System.out.println("flg:"+demo6.flg); // 未初始化的 Boolean 字段类型 值为：flase

    }

//    Demo5
    public static void main5 (String[] args) {
        Demo5 demo = new Demo5(); // new 一个对象，产生对象，实例化对象，可以实例化多个对象，
                                  // 但是每个对象是相互独立的，互不干扰的
//        如何访问静态变量数据成员和方法：类名 + 静态成员变量名
        int num = Demo5.size;
        System.out.println("num:"+num);
//        如何访问静态的方法 ： 类名 + 静态方法名
        Demo5.test();
    }



//    Demo4
    public static void main4 (String[] args) {
        Demo4 demo4 = new Demo4(); // new 一个对象，产生对象，实例化对象，可以实例化多个对象，但是它们是相互独立的，互不干扰的
        Demo4 demo5 = new Demo4(); // new 一个对象，产生对象，实例化对象，可以实例化多个对象，但是它们是相互独立的，互不干扰的
        Demo4 demo6 = new Demo4(); // new 一个对象，产生对象，实例化对象，可以实例化多个对象，但是它们是相互独立的，互不干扰的

        System.out.println(Demo4.size); // 访问 static 静态变量的方式：类名 + 变量名
        /*如何访问对象当中的实例成员变量
        * 操作符 . 点号 使用. 来访问对象中的属性和方法
        * 同一个类可以创建多个实例，
        * */
        System.out.println(demo4.name); // 未初始化的 String 字符串类型 默认值为 null 空，不是 0
    }


//    Demo3
    public static void main3 (String[] args) {
        Demo3 demo3 = new Demo3(); // new 一个对象，实例化对象，可以实例化多个对象，但是每个对象都是，相互独立的，互不干扰的
        Demo3 demo4 = new Demo3(); // new 一个对象，实例化对象，可以实例化多个对象，但是每个对象都是，相互独立的，互不干扰的
        Demo3 demo5 = new Demo3(); // new 一个对象，实例化对象，可以实例化多个对象，但是每个对象都是，相互独立的，互不干扰的

        demo3.age = 18;
        demo3.name = "demo3";
        demo4.age = 19;
        demo4.name = "demo4";
        demo5.age = 20;
        demo5.name = "demo5";

        System.out.println(demo3.name);
        System.out.println(demo3.age);
        demo3.getEat();
        demo3.getSleep();
        System.out.println("********************");
        System.out.println(demo4.name);
        System.out.println(demo4.age);
        demo4.getEat();
        demo4.getSleep();
        System.out.println("*********************");
        System.out.println(demo5.name);
        System.out.println(demo5.age);
        demo5.getEat();
        demo5.getSleep();

    }


//    Demo2
    public static void main2 (String[] args) {
        Demo2 demo2 = new Demo2(); // nem  产生对象，实例化对象，
        demo2.age = 18; // 使用对象
        demo2.name = "你好世界";
        System.out.println(demo2.age);
        System.out.println(demo2.name);
        demo2.getAge();
        demo2.getName();
        System.out.println("**************************");
        System.out.println(demo2.age);
        System.out.println(demo2.name);

    }



//    Demo1
    public static void main01 (String[] args) {
        Demo1 demo1 = new Demo1(); // 实例化对象，通过new 实例化对象，
        demo1.age = 18; // 引用对象中的成员变量
        demo1.name = "你好世界";
        System.out.println(demo1.age);
        System.out.println(demo1.name);

    }

}
